///*
// *  Copyright 2019-2020
// *
// *  Licensed under the Apache License, Version 2.0 (the "License");
// *  you may not use this file except in compliance with the License.
// *  You may obtain a copy of the License at
// *
// *  http://www.apache.org/licenses/LICENSE-2.0
// *
// *  Unless required by applicable law or agreed to in writing, software
// *  distributed under the License is distributed on an "AS IS" BASIS,
// *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// *  See the License for the specific language governing permissions and
// *  limitations under the License.
// */
//package cn.cdeden.sys.utils;
//
//import cn.cdeden.common.core.utils.StringUtils;
//import cn.hutool.core.util.IdUtil;
//import cn.hutool.extra.spring.SpringUtil;
//import cn.hutool.poi.excel.BigExcelWriter;
//import cn.hutool.poi.excel.ExcelUtil;
//import com.alibaba.fastjson.JSONObject;
//import com.cdyd.ecm.config.FileProperties;
//import com.cdyd.ecm.config.OnlineConfig;
//import com.cdyd.ecm.exception.BadRequestException;
//import com.itextpdf.text.Document;
//import com.itextpdf.text.DocumentException;
//import com.itextpdf.text.Element;
//import com.itextpdf.text.exceptions.BadPasswordException;
//import com.itextpdf.text.pdf.*;
//import jakarta.servlet.ServletOutputStream;
//import jakarta.servlet.http.HttpServletRequest;
//import jakarta.servlet.http.HttpServletResponse;
//import lombok.extern.slf4j.Slf4j;
//import org.apache.coyote.BadRequestException;
//import org.apache.poi.ss.usermodel.*;
//import org.apache.poi.util.IOUtils;
//import org.apache.poi.xslf.usermodel.*;
//import org.apache.poi.xssf.streaming.SXSSFCell;
//import org.apache.poi.xssf.streaming.SXSSFRow;
//import org.apache.poi.xssf.streaming.SXSSFSheet;
//import org.apache.poi.xssf.usermodel.XSSFWorkbook;
//import org.apache.poi.xwpf.usermodel.XWPFDocument;
//import org.apache.poi.xwpf.usermodel.XWPFParagraph;
//import org.apache.poi.xwpf.usermodel.XWPFRun;
//import org.apache.tika.Tika;
//import org.apache.tika.exception.TikaException;
//import org.apache.tika.metadata.HttpHeaders;
//import org.apache.tika.metadata.Metadata;
//import org.apache.tika.metadata.TikaMetadataKeys;
//import org.apache.tika.parser.AutoDetectParser;
//import org.apache.tika.parser.ParseContext;
//import org.springframework.core.io.PathResource;
////import org.springframework.mock.web.MockMultipartFile;
//import org.springframework.web.multipart.MultipartFile;
//import org.w3c.dom.Node;
//import org.w3c.dom.NodeList;
//import org.xml.sax.InputSource;
//import org.xml.sax.SAXException;
//import org.xml.sax.helpers.DefaultHandler;
//import sun.font.FontDesignMetrics;
//
//import javax.imageio.ImageIO;
//import javax.imageio.stream.FileImageOutputStream;
//import javax.servlet.ServletOutputStream;
//import javax.servlet.http.HttpServletRequest;
//import javax.servlet.http.HttpServletResponse;
//import javax.swing.*;
//import javax.xml.parsers.DocumentBuilder;
//import javax.xml.parsers.DocumentBuilderFactory;
//import java.awt.Color;
//import java.awt.Font;
//import java.awt.*;
//import java.awt.geom.Rectangle2D;
//import java.awt.image.BufferedImage;
//import java.io.*;
//import java.net.HttpURLConnection;
//import java.net.MalformedURLException;
//import java.net.URL;
//import java.net.URLEncoder;
//import java.nio.charset.StandardCharsets;
//import java.nio.file.Files;
//import java.nio.file.Path;
//import java.security.MessageDigest;
//import java.text.DecimalFormat;
//import java.text.SimpleDateFormat;
//import java.util.List;
//import java.util.*;
//
//
///**
// * File工具类，扩展 hutool 工具包
// *
// * @author
// * @date 2018-12-27
// */
//@Slf4j
//public class FileUtil extends cn.hutool.core.io.FileUtil {
//
//
//    public final static String key = "Ez3uGBYAMgEAdycViEDkKaeQKVGBWYj3iIeYpLhOgi+8gumB3r8LBKDaD1eHMvZkL6zeG9YWhS+y1zX73jLuaE35Q24LJ/VPyjS5kqMAqzqCA4Kw5l3bLkNRSmkjRcuug5K/+xUkJpqeY2b5ZilFjZFMFa4KL5iPl/bvdCDXQjSOHt2dLP1LiE4GX4vTWRHuO+COGSOqelxIy5UwWd0dOH6Ofjt0HSiRZbcefxoG3fG7a4ah32OomYC9+wqyIi1T3sbJqD/DzKqAqAVMeSsQpGlV8qiyabNdrLASocUOT5n4ry2wXm2xhrdA8ILIPOD4PkOVx9KpQllzYBNzSvgOWvG/gK7ufYQJ5Lg9B4+j3QjCa5f5d2y53wEAAiL5ehMAItVJbCcRug1NdB1l8oHsx4uAs4t5buurCW6RrmIRG94O82LRt0L8i0faa9dJi0s+Q+zHA2C9qRew7R9NCiz5q5bEX5z/pBBis3souuU4EdZNr+5uy9MOr7MD0zaUTE7g1tm821aitHp/VJYhBtQrmxDNbVyaoPEwfG/D4MXPZE8AVhYZ1SgfZBISPWx6+djAqycdRMQPE4K7GLgKnIBjhmwxG81S1HtymbLkdyCOmOcYrqioYa3/jmlOJVuXXaZCIKvdqThRUdQfD29PhJ6D+Q2KsLMMC0ZIZUfTTAMPrkaihD8GokOuHu1XI1TbbXN1MRNZw1sBgU9ju+M1v9RHA+8tstZZRwbvfpC+y/8h9znvTPtolHx2k7fkl6EQVnVUIaxYcvDgf6tB/rb7yqFT1CxSwoCTGH4+HvmV9Km1S2v+xaNhHkyMQcbzgpYkd4coDww697HShyOBXxnO3kWydsiJihmqHQGO5J2jhbOFwTaNdySc/q5/r2kBVW1JaOF4WS2vIH39ZAgFqHELsde5ybLo5h5KSzQJ3I3yumkqQsXf8UVH8HHhrV+Oa1wQn4Pup27Hlpj5DdhgMTJ2KHKrwYyZHfmGkiaK+2W7eEnBYaOMRMyUtwjECI7OB4GEuUNv/6GFmDreA5HXhbAnd0G6y4rGccOhP0N60B3UD5gwugbHohciZhydCrvwBZdcG5o3iJFAVnM8/73qWwAxQ8h5/DV2EPJ1H2l2gBqiIMbq75rfGHViMcBHyHteXBLNF0qltCDlPWoMGSHMWO3ItwIhx7ekgnkIxwZezQx2wUQvKqTCLohcR5PkaQD1qiKdxXfQiLc5G77nGEDxNJ8Oz5mk4tovKjUs6dvFVb6emuZ1apZjC4E3ZJS+tVHZj+BB7GPjjOMauG7xaE9NXpycsPp9iCj7h5iwp3c7li+lH8BfCsOKANpJjJu3fQulUqXPH6TgnUDMkTpgpKviVoGkKrPVlPaJXIMbtXABO5ByjPwx7rAljBtXb3r5799+avg1p/FfVNglK2m4h93I4WW9DV4DNzklngAgZlS0dmNUkJ03ApTR1EwHrIgBGZVXFFKC6AhFhBeN5rC5rR+S15soRqd99+DUEM4XNWg5OZMuYsns05NvIajADdKDQyVp9YYv7WLnpTGRJm9dVKtAirXHU8vecbEor26ypEXZkJJ9MsgftC6O69+GVw3xkM/7RzRWL1EYPP4DNj5M+x1iCMGEK1KaRFSvimoFuyqLRFrftcExu6VRld+A8vRteg==";
//
//
//
////    private static final Logger log = LoggerFactory.getLogger(FileUtil.class);
//
//    /**
//     * 系统临时目录
//     * <br>
//     * windows 包含路径分割符，但Linux 不包含,
//     * 在windows \\==\ 前提下，
//     * 为安全起见 同意拼装 路径分割符，
//     * <pre>
//     *       java.io.tmpdir
//     *       windows : C:\Users/xxx\AppData\Local\Temp\
//     *       linux: /temp
//     * </pre>
//     */
//    public static final String SYS_TEM_DIR = System.getProperty("java.io.tmpdir") + File.separator;
//    /**
//     * 定义TB的计算常量
//     */
////    private static final long TB = 1024 * 1024 * 1024 * 1024; // final  无法计算
//    private static final long TB = 1099511627776L;
//    /**
//     * 定义GB的计算常量
//     */
//    private static final long GB = 1073741824L;
////    private static final long GB = 1024 * 1024 * 1024;
//    /**
//     * 定义MB的计算常量
//     */
//    private static final long MB = 1048576L;
////    private static final long MB = 1024 * 1024;
//    /**
//     * 定义KB的计算常量
//     */
//    private static final long KB = 1024L;
//
//    /**
//     * 格式化小数
//     */
//    private static final DecimalFormat DF = new DecimalFormat("0.00");
//
//    public static final String IMAGE = "图片";
//    public static final String TXT = "文档";
//    public static final String MUSIC = "音乐";
//    public static final String VIDEO = "视频";
//    public static final String OTHER = "其他";
//
//
//    public static MultipartFile getMultipartFile(File file) {
//        MultipartFile multipartFile = null;
//        try {
//            InputStream inputStream = new FileInputStream(file);
//            Tika tika = new Tika(); // 识别文件类型
//            String detectedContentType = tika.detect(file);
//            multipartFile = new MockMultipartFile(file.getName(), file.getName(), detectedContentType, inputStream);
//        } catch (FileNotFoundException e) {
//            throw new RuntimeException(e);
//        } catch (IOException e) {
//            throw new RuntimeException(e);
//        }
//        return multipartFile;
//    }
//
//    /**
//     * file转MultipartFile
//     *
//     * @param file file
//     * @return MultipartFile
//     */
//    public static MultipartFile fileToMultipartFile(File file) {
//        return fileToMultipartFile(file, file.getName());
//
//    }
//
//    public static MultipartFile fileToMultipartFile(File file, String fileName) {
//        MultipartFile result = null;
//        if (null != file) {
//            try (FileInputStream input = new FileInputStream(file)) {
//                String mimeType = Files.probeContentType(file.toPath());
//                result = new MockMultipartFile(file.getName().concat("temp"), fileName, mimeType, input);
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
//        }
//        return result;
//    }
//
//
//    public static File getFile(FileProperties properties) {
//        String tmp = properties.getPath().getTmp();
////        new  File(tmp)
//        String uuid = IdUtil.simpleUUID();
//        return createFile(tmp + "\\" + uuid + ".txt");
//    }
//
//
//    /**
//     * 获取文件扩展名，不带 .
//     */
//    public static String getExtensionName(String filename) {
//        if ((filename != null) && (filename.length() > 0)) {
//            int dot = filename.lastIndexOf('.');
//            if ((dot > -1) && (dot < (filename.length() - 1))) {
//                return filename.substring(dot + 1);
//            }
//        }
//        return filename;
//    }
//
//    /**
//     * Java文件操作 获取不带扩展名的文件名
//     */
//    public static String getFileNameNoEx(String filename) {
//        if ((filename != null) && (filename.length() > 0)) {
//            int dot = filename.lastIndexOf('.');
//            if ((dot > -1) && (dot < (filename.length()))) {
//                return filename.substring(0, dot);
//            }
//        }
//        return filename;
//    }
//
//    /**
//     * 文件大小转换
//     */
//    public static String getSize(long size) {
//        String resultSize;
//        if (size == 0) {
//            resultSize = size + "B ";
//        } else if (size / TB >= 1) {
//            //如果当前Byte的值大于等于1GB
//            resultSize = DF.format(size / (float) TB) + "TB ";
//        } else if (size / GB >= 1) {
//            //如果当前Byte的值大于等于1GB
//            resultSize = DF.format(size / (float) GB) + "GB ";
//        } else if (size / MB >= 1) {
//            //如果当前Byte的值大于等于1MB
//            resultSize = DF.format(size / (float) MB) + "MB ";
//        } else if (size / KB >= 1) {
//            //如果当前Byte的值大于等于1KB
//            resultSize = DF.format(size / (float) KB) + "KB ";
//        } else {
//            resultSize = size + "B ";
//        }
//        return resultSize;
//    }
//
//    /**
//     * inputStream 转 File
//     */
//    static File inputStreamToFile(InputStream ins, String name) {
//        File file = new File(SYS_TEM_DIR + name);
//        if (file.exists()) {
//            return file;
//        }
//        OutputStream os = null;
//        try {
//            os = new FileOutputStream(file);
//            int bytesRead;
//            int len = 8192;
//            byte[] buffer = new byte[len];
//            while ((bytesRead = ins.read(buffer, 0, len)) != -1) {
//                os.write(buffer, 0, bytesRead);
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        } finally {
//            CloseUtil.close(os);
//            CloseUtil.close(ins);
//        }
//        return file;
//    }
//
//    /**
//     * 将文件名解析成文件的上传路径
//     */
//    public static File upload(MultipartFile file, String filePath) {
//        Date date = new Date();
//        SimpleDateFormat format = new SimpleDateFormat("yyyyMMddhhmmssS");
//        String name = getFileNameNoEx(file.getOriginalFilename());
//        String suffix = getExtensionName(file.getOriginalFilename());
//        String nowStr = "-" + format.format(date);
//        try {
//            String fileName = name + nowStr + "." + suffix;
//            String path = filePath + fileName;
//            // getCanonicalFile 可解析正确各种路径
//            File dest = new File(path).getCanonicalFile();
//            // 检测是否存在目录
//            if (!dest.getParentFile().exists()) {
//                if (!dest.getParentFile().mkdirs()) {
//                    System.out.println("was not successful.");
//                }
//            }
//            // 文件写入
//            file.transferTo(dest);
//            return dest;
//        } catch (Exception e) {
//            log.error(e.getMessage(), e);
//        }
//        return null;
//    }
//
//    public static void downloadExcel(List<Map<String, Object>> list, HttpServletResponse response) throws IOException {
//        downloadExcel(list, response,"file",null);
//    }
//
//    public static void downloadExcel(HttpServletResponse response,List<Map<String, Object>>... list) throws IOException {
//        downloadExcel(response,"file",null,list);
//    }
//
//    public static void downloadExcel(List<Map<String, Object>> list, HttpServletResponse response, String fileName) throws IOException {
//        downloadExcel(list, response,fileName,null);
//    }
//
//
//    /**
//     * 导出excel
//     */
//    public static void downloadExcel(List<Map<String, Object>> list, HttpServletResponse response, String fileName, String header) throws IOException {
//        String tempPath = SYS_TEM_DIR + IdUtil.fastSimpleUUID() + ".xlsx";
//        File file = new File(tempPath);
//        try {
//            BigExcelWriter writer = ExcelUtil.getBigWriter(file);
//
//            Integer columnCount = list.get(0).size(); // 获取列数
//            SXSSFSheet sheet = (SXSSFSheet) writer.getSheet();
//
//            // 判断是否有header，如果有则先处理header的合并与样式
//            if (StringUtils.isNotBlank(header)) {
//                int lastColumnIndex = columnCount - 1; // 计算最后一列的索引
//                // 创建或获取默认样式
//                CellStyle defaultCellStyle = writer.getStyleSet().getHeadCellStyle();
//                defaultCellStyle.setWrapText(true); // 设置自动换行
//                CellStyle mergeCellStyle = writer.getWorkbook().createCellStyle();
//                mergeCellStyle.cloneStyleFrom(defaultCellStyle); // 复制默认样式
//                mergeCellStyle.setFillForegroundColor(IndexedColors.WHITE.getIndex()); // 设置背景颜色为白色
//                mergeCellStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND); // 设置填充模式为实心填充
//
//
//                // 写入表头行
//                writer.writeRow(list.get(0), false);
//                // 插入一行在最上面
//
////                writer.insertRow(writer, startRow, rows, sheet,false);
//                // 合并表头单元格并应用样式
//                writer.merge(0, 0, 0, lastColumnIndex, header, mergeCellStyle);
//
//                // 设置表头行高
//                writer.setRowHeight(0, 100);
////                writer.setC
//            }
//
//
//            // 一次性写出内容，使用默认样式，强制输出标题
//            writer.write(list, true);
//
//            // 自适应列宽并支持中文
//            sheet.trackAllColumnsForAutoSizing();
//            sizeChineseColumn02(sheet,columnCount,header);
//
//
//
//
//            // 设置响应参数
//            response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=utf-8");
//            //.xls是弹出下载对话框的文件名，不能为中文，中文请自行编码
//            fileName = URLEncoder.encode(fileName, "UTF-8");
//            response.setHeader("Content-Disposition", "attachment;filename=" + fileName + ".xlsx");
//
//            try (ServletOutputStream out = response.getOutputStream()) {
//                writer.flush(out, true);
//            }
//        } catch (Exception e) {
//            throw e;
//        } finally {
//            if (file.exists()) {
//                file.delete(); // 删除临时文件
//            }
//        }
//    }
//
//    /**
//     * 导出excel(多sheet)
//     */
//    public static void downloadExcel( HttpServletResponse response, String fileName, String header,List<Map<String, Object>>... lists) throws IOException {
//        String tempPath = SYS_TEM_DIR + IdUtil.fastSimpleUUID() + ".xlsx";
//        File file = new File(tempPath);
//        int i=0;
//        try {
//            BigExcelWriter writer = ExcelUtil.getBigWriter(file);
//            for (List<Map<String, Object>> list : lists){
//                writer.setSheet(i);
//                if (list.size() > 0) {
//                    Integer columnCount = list.get(0).size(); // 获取列数
//                    SXSSFSheet sheet = (SXSSFSheet) writer.getSheet();
//
//                    // 判断是否有header，如果有则先处理header的合并与样式
//                    if (StringUtils.isNotBlank(header)) {
//                        int lastColumnIndex = columnCount - 1; // 计算最后一列的索引
//                        // 创建或获取默认样式
//                        CellStyle defaultCellStyle = writer.getStyleSet().getHeadCellStyle();
//                        defaultCellStyle.setWrapText(true); // 设置自动换行
//                        CellStyle mergeCellStyle = writer.getWorkbook().createCellStyle();
//                        mergeCellStyle.cloneStyleFrom(defaultCellStyle); // 复制默认样式
//                        mergeCellStyle.setFillForegroundColor(IndexedColors.WHITE.getIndex()); // 设置背景颜色为白色
//                        mergeCellStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND); // 设置填充模式为实心填充
//
//
//                        // 写入表头行
//                        writer.writeRow(list.get(0), false);
//                        // 插入一行在最上面
//
////                writer.insertRow(writer, startRow, rows, sheet,false);
//                        // 合并表头单元格并应用样式
//                        writer.merge(0, 0, 0, lastColumnIndex, header, mergeCellStyle);
//
//                        // 设置表头行高
//                        writer.setRowHeight(0, 100);
////                writer.setC
//                    }
//
//
//                    // 一次性写出内容，使用默认样式，强制输出标题
//                    writer.write(list, true);
//                    // 自适应列宽并支持中文
//                    sheet.trackAllColumnsForAutoSizing();
//                    sizeChineseColumn02(sheet, columnCount, header);
//                    i++;
//                }
//            }
//
//
//
//
//
//            // 设置响应参数
//            response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=utf-8");
//            //.xls是弹出下载对话框的文件名，不能为中文，中文请自行编码
//            fileName = URLEncoder.encode(fileName, "UTF-8");
//            response.setHeader("Content-Disposition", "attachment;filename=" + fileName + ".xlsx");
//
//            try (ServletOutputStream out = response.getOutputStream()) {
//                writer.flush(out, true);
//            }
//        } catch (Exception e) {
//            throw e;
//        } finally {
//            if (file.exists()) {
//                file.delete(); // 删除临时文件
//            }
//        }
//    }
//
//
//    /**
//     * 自适应宽度(中文支持)
//     */
//    private static void sizeChineseColumn(SXSSFSheet sheet, BigExcelWriter writer) {
//        for (int columnNum = 0; columnNum < writer.getColumnCount(); columnNum++) {
//            int columnWidth = sheet.getColumnWidth(columnNum) / 256;
//            for (int rowNum = 0; rowNum < sheet.getLastRowNum(); rowNum++) {
//                SXSSFRow currentRow;
//                if (sheet.getRow(rowNum) == null) {
//                    currentRow = sheet.createRow(rowNum);
//                } else {
//                    currentRow = sheet.getRow(rowNum);
//                }
//                if (currentRow.getCell(columnNum) != null) {
//                    SXSSFCell currentCell = currentRow.getCell(columnNum);
//                    if (currentCell.getCellType() == CellType.STRING) {
//                        int length = currentCell.getStringCellValue().getBytes().length;
//                        if (columnWidth < length) {
//                            columnWidth = length;
//                        }
//                    }
//                }
//            }
////            sheet.setColumnWidth(columnNum, columnWidth * 256 > 255 ? 255 : columnWidth * 256);
//            sheet.setColumnWidth(columnNum, columnWidth * 256 );
//        }
//    }
//
//
//
//    private static void sizeChineseColumn02(SXSSFSheet sheet, int columnCount,String header) {
//        for (int columnNum = 0; columnNum < columnCount; columnNum++) {
//            int columnWidth = 0;
//            int rowNum01 = StringUtils.isBlank(header) ? 0 : 1;
//            for (int rowNum = rowNum01; rowNum <= sheet.getLastRowNum(); rowNum++) {
//                SXSSFRow currentRow = sheet.getRow(rowNum);
//                if (currentRow != null) {
//                    SXSSFCell currentCell = currentRow.getCell(columnNum);
//                    if (currentCell != null) {
//                        int length = 0;
//                        if (currentCell.getCellType() == CellType.STRING) {
//                            // 计算字符串列的宽度
//                            length = currentCell.getStringCellValue().length() +
//                                    currentCell.getStringCellValue().getBytes().length -
//                                    currentCell.getStringCellValue().length();
//                        } else if (currentCell.getCellType() == CellType.NUMERIC) {
//                            // 计算数字列的宽度
//                            length = currentCell.toString().length();
//                        }
//                        if (columnWidth < length) {
//                            columnWidth = length;
//                        }
//                    }
//                }
//            }
//            // 计算最终列宽，调整补偿像素
//            int finalWidth = (columnWidth + 2) * 256; // +2是为了增加少许的额外空间
//            finalWidth = Math.min(finalWidth, 65280); // 限制最大宽度
//            sheet.setColumnWidth(columnNum, finalWidth);
//        }
//    }
//
//    public static String getFileType(String type) {
//        String documents = "txt doc pdf ppt pps xlsx xls docx";
//        String music = "mp3 wav wma mpa ram ra aac aif m4a";
//        String video = "avi mpg mpe mpeg asf wmv mov qt rm mp4 flv m4v webm ogv ogg";
//        String image = "bmp dib pcp dif wmf gif jpg tif eps psd cdr iff tga pcd mpt png jpeg";
//        if (image.contains(type)) {
//            return IMAGE;
//        } else if (documents.contains(type)) {
//            return TXT;
//        } else if (music.contains(type)) {
//            return MUSIC;
//        } else if (video.contains(type)) {
//            return VIDEO;
//        } else {
//            return OTHER;
//        }
//    }
//
//    public static List<String> getDocument(String type) {
//        String word = "txt doc docx";
//        String ppt = "ppt pps pptx";
//        String excel = "xlsx xls";
//        if (type == null) {
//            return null;
//        } else if ("word".equals(type)) {
//            return Arrays.asList(word.split(" "));
//        } else if ("ppt".equals(type)) {
//            return Arrays.asList(ppt.split(" "));
//        } else if ("excel".equals(type)) {
//            return Arrays.asList(excel.split(" "));
//        } else {
//            return null;
//        }
//    }
//
//    public static String getDocumentType(String suffix) {
//        String word = "txt doc docx";
//        List<String> wordList = Arrays.asList(word.split(" "));
//        String ppt = "ppt pps pptx";
//        List<String> pptList = Arrays.asList(ppt.split(" "));
//        String excel = "xlsx xls";
//        List<String> excelList = Arrays.asList(excel.split(" "));
//        for (String s : wordList) {
//            if (suffix.equals(s)) return "word";
//        }
//        for (String s : pptList) {
//            if (suffix.equals(s)) return "ppt";
//        }
//        for (String s : excelList) {
//            if (suffix.equals(s)) return "excel";
//        }
//        return null;
//    }
//
//    /**
//     * @param dirFile //只传文件夹路径
//     * @return void
//     * @author Yu.
//     * @Description // 检查文件是否存在不存在就创建他
//     * @Date 2022/12/2 11:10
//     **/
//    public static void createFolder(String dirFile) {
//        if (dirFile.charAt(dirFile.length() - 1) == '/' || dirFile.charAt(dirFile.length() - 1) == '\\') { //s.length()-1获取字符串最后一位字符的索引，传入charAt方法获取索引对应的字符，判断是否为
////            System.out.println(dirFile.substring(0, dirFile.length()-1)); //，则通过substring截取需要的值
//            dirFile = dirFile.substring(0, dirFile.length() - 1);
//        }
//        if (dirFile.contains("\\")) {
//            dirFile = dirFile.replace("\\", "/");
//        }
//
//        File file = new File(dirFile + "/123.txt");
////        File file = new File(dirFile);
//        if (file.exists()) {
//            log.info("文件夹存在");
//        } else {
//            //getParentFile() 获取上级目录(包含文件名时无法直接创建目录的)
//            boolean b = !file.getParentFile().exists();
//            if (b) {
//                log.info("不存在 创建上级目录.." + dirFile);
//                //创建上级目录
//                file.getParentFile().mkdirs();
//            } else {
//                log.info("文件存在目录.." + dirFile);
//            }
//        }
//    }
//
//
//    public static File createFile(String dirFile) {
//        File file = new File(dirFile);
//        if (file.exists()) {
//            log.info("文件夹存在");
//        } else {
//            log.info("文件不存在创建他 ...");
//            //getParentFile() 获取上级目录(包含文件名时无法直接创建目录的)
//            boolean b = !file.getParentFile().exists();
//            if (b) {
//                log.info("不存在 创建上级目录..");
//                //创建上级目录
//                file.getParentFile().mkdirs();
//            }
//            try {
//                //在上级目录里创建文件
//                log.info("不存在 创建文件.. ");
//                file.createNewFile();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
//        }
//        return file;
//    }
//
//
//    /**
//     * MultipartFile 转 File
//     *
//     * @param multipartFile
//     * @throws Exception
//     */
//
//
////    @Autowired
////    private static FileProperties properties;
//    public static File multipartFileToFile(MultipartFile multipartFile, String path, boolean b) {
//        if (path.charAt(path.length() - 1) == '/' || path.charAt(path.length() - 1) == '\\') { //s.length()-1获取字符串最后一位字符的索引，传入charAt方法获取索引对应的字符，判断是否为
////            System.out.println(dirFile.substring(0, dirFile.length()-1)); //，则通过substring截取需要的值
//            path = path.substring(0, path.length() - 1);
//        }
//        if (path.contains("\\")) {
//            path = path.replace("\\", "/");
//        }
//        File file = null;
//        //判断是否为null
//        if (multipartFile.equals("") || multipartFile.getSize() <= 0) {
//            return file;
//        }
//        //MultipartFile转换为File
//        InputStream ins = null;
//        OutputStream os = null;
//        try {
//            ins = multipartFile.getInputStream();
//            createFolder(path); //先创建文件夹
//            String s = "";
//            if (b) {
//                s = "multipartFileToFile-" + IdUtil.simpleUUID() + "-";
//            }
//            String s1 = path + "/" + s + multipartFile.getOriginalFilename();
//            file = createFile(s1);
//            os = new FileOutputStream(file);
//            int bytesRead = 0;
//            byte[] buffer = new byte[8192];
//            while ((bytesRead = ins.read(buffer, 0, 8192)) != -1) {
//                os.write(buffer, 0, bytesRead);
//            }
//            log.info("文件储存地址：{}", s1);
//            return new File(s1);
//        } catch (IOException e) {
//            e.printStackTrace();
//        } finally {
//            if (os != null) {
//                try {
//                    os.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//            if (ins != null) {
//                try {
//                    ins.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//
//        }
//        return file;
//    }
//
////    public static File multipartFileToFile(MultipartFile multipartFile,FileProperties properties) {
////        return  multipartFileToFile(multipartFile,properties.getPath().getTmp()+"\\turn" ,false);
////    }
//
//    public static File multipartFileToFile(MultipartFile multipartFile, FileProperties properties, boolean b) {
//        return multipartFileToFile(multipartFile, properties.getPath().getTmp() + "turn", b);
//    }
//
//    public static String getFileType(File file) {
//        if (file.isDirectory()) {
//            return "the target is a directory";
//        }
//        AutoDetectParser parser = new AutoDetectParser();
//        parser.setParsers(new HashMap<>());
//        Metadata metadata = new Metadata();
//        metadata.add(TikaMetadataKeys.RESOURCE_NAME_KEY, file.getName());
//        try {
//            InputStream stream = new FileInputStream(file);
//            parser.parse(stream, new DefaultHandler(), metadata, new ParseContext());
//            stream.close();
//        } catch (IOException | SAXException | TikaException e) {
//            throw new RuntimeException(e);
//        }
//        return metadata.get(HttpHeaders.CONTENT_TYPE);
//    }
//
//
//    public static void checkSize(long maxSize, long size) throws BadRequestException {
//        // 1M
//        int len = 1024 * 1024;
//        if (size > (maxSize * len)) {
//            throw new BadRequestException("文件超出规定大小");
//        }
//    }
//
//    /**
//     * 判断两个文件是否相同
//     */
//    public static boolean check(File file1, File file2) {
//        String img1Md5 = getMd5(file1);
//        String img2Md5 = getMd5(file2);
//        if (img1Md5 != null) {
//            return img1Md5.equals(img2Md5);
//        }
//        return false;
//    }
//
//    /**
//     * 判断两个文件是否相同
//     */
//    public static boolean check(String file1Md5, String file2Md5) {
//        return file1Md5.equals(file2Md5);
//    }
//
//    private static byte[] getByte(File file) {
//        // 得到文件长度
//        byte[] b = new byte[(int) file.length()];
//        InputStream in = null;
//        try {
//            in = new FileInputStream(file);
//            try {
//                System.out.println(in.read(b));
//            } catch (IOException e) {
//                log.error(e.getMessage(), e);
//            }
//        } catch (Exception e) {
//            log.error(e.getMessage(), e);
//            return null;
//        } finally {
//            CloseUtil.close(in);
//        }
//        return b;
//    }
//
//    private static String getMd5(byte[] bytes) {
//        // 16进制字符
//        char[] hexDigits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
//        try {
//            MessageDigest mdTemp = MessageDigest.getInstance("MD5");
//            mdTemp.update(bytes);
//            byte[] md = mdTemp.digest();
//            int j = md.length;
//            char[] str = new char[j * 2];
//            int k = 0;
//            // 移位 输出字符串
//            for (byte byte0 : md) {
//                str[k++] = hexDigits[byte0 >>> 4 & 0xf];
//                str[k++] = hexDigits[byte0 & 0xf];
//            }
//            return new String(str);
//        } catch (Exception e) {
//            log.error(e.getMessage(), e);
//        }
//        return null;
//    }
//
//    /**
//     * 下载文件
//     *
//     * @param request  /
//     * @param response /
//     * @param file     /
//     */
//    public static void downloadFile(HttpServletRequest request, HttpServletResponse response, File file, boolean deleteOnExit) {
//        response.setCharacterEncoding(request.getCharacterEncoding());
//        response.setContentType("application/octet-stream");
//        FileInputStream fis = null;
//        try {
//            fis = new FileInputStream(file);
//            response.setHeader("Content-Disposition", "attachment; filename=" + file.getName());
//            IOUtils.copy(fis, response.getOutputStream());
//            response.flushBuffer();
//        } catch (Exception e) {
//            log.error(e.getMessage(), e);
//        } finally {
//            if (fis != null) {
//                try {
//                    fis.close();
//                    if (deleteOnExit) {
//                        file.deleteOnExit();
//                    }
//                } catch (IOException e) {
//                    log.error(e.getMessage(), e);
//                }
//            }
//        }
//    }
//
//    public static void downloadFileByStream(HttpServletRequest request, HttpServletResponse response, String fileName) {
//        response.setCharacterEncoding(request.getCharacterEncoding());
//        response.setContentType("application/octet-stream");
//        OutputStream responseOutputStream = null;
//        try {
//            fileName = URLEncoder.encode(fileName, "UTF-8");
////            response.setHeader("Content-Disposition", "attachment; filename=" + fileName + ";filename*=UTF-8" + fileName);
//            response.setHeader("Content-Disposition", "attachment; filename=" + fileName);
//            response.flushBuffer();
//        } catch (Exception e) {
//            log.error(e.getMessage(), e);
//        } finally {
//            if (responseOutputStream != null) {
//                try {
//                    responseOutputStream.close();
//                } catch (IOException e) {
//                    log.error(e.getMessage(), e);
//                }
//            }
//        }
//    }
//
//    public static String getMd5(File file) {
//        return getMd5(getByte(file));
//    }
//
//    /**
//     * 下载网络文件
//     *
//     * @param fileUrl 网络文件URL地址
//     * @return 文件的二进制字节数组数据
//     * @throws MalformedURLException
//     */
//    public static byte[] downloadNetworkFile(String fileUrl) throws MalformedURLException {
//        URL ur = new URL(fileUrl);
//        BufferedInputStream in = null;
//        ByteArrayOutputStream out = null;
//        try {
//            //获取网络文件的输入流
//            in = new BufferedInputStream(ur.openStream());
//            out = new ByteArrayOutputStream(1024);
//            byte[] temp = new byte[1024];
//            int size = 0;
//            while ((size = in.read(temp)) != -1) {
//                out.write(temp, 0, size);
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        } finally {
//            try {
//                if (in != null) {
//                    in.close();
//                }
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
//        }
//        if (out != null) {
//            return out.toByteArray();
//        } else {
//            return null;
//        }
//    }
//
//    /**
//     * 通过文件字节流获取文件类型
//     *
//     * @param file 文件
//     * @return Type of file
//     */
//    public static String getFileHeader(MultipartFile file) {
//        InputStream is = null;
//        String value = null;
//        try {
//            is = file.getInputStream();
//
//            byte[] b = new byte[10];
//
//            is.read(b, 0, b.length);
//
//            value = checkFileType(Objects.requireNonNull(bytesToHexString(b)));
//        } catch (Exception e) {
//            e.printStackTrace();
//        } finally {
//            if (null != is) {
//                try {
//                    is.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//        }
//        return value;
//    }
//
//    private static String bytesToHexString(byte[] src) {
//        StringBuilder builder = new StringBuilder();
//        if (src == null || src.length <= 0) {
//            return null;
//        }
//        String hv;
//        for (byte b : src) {
//            hv = Integer.toHexString(b & 0xFF).toLowerCase();
//            if (hv.length() < 2) {
//                builder.append(0);
//            }
//            builder.append(hv);
//        }
//        return builder.toString();
//    }
//
//    public static void deleteFile(File file) {
//        if (file.delete()) {
//            System.out.println("删除文件: " + file.getName());
//        } else {
//            System.out.println("删除文件失败");
//
//        }
//    }
//
//
//    public static String checkFileType(String x) {
//        switch (x) {
//            case "255044462d312e360d25":
//                return TXT;             //"pdf";
//            case "e69292e58f91e8bebee6":
//                return TXT;             //"txt";
//            case "d0cf11e0a1b11ae10000":
//                return TXT;             //"doc,ppt,xls";
//            case "504b0304140006000800":
//                return TXT;             //"docx,xlsx";
//            case "504b0304140008080800":
//                return TXT;
//            case "504b03040a0000000000":
//                return TXT;             //"pptx,jar";
//            case "e59bbee58583e7b1bbe5":
//                return TXT;             //slx;
//            case "89504e470d0a1a0a0000":
//                return IMAGE;           //"png";
//            case "ffd8ffe000104a464946":
//                return IMAGE;           //"jpg.jpeg";
//            case "4749463839612602601":
//                return IMAGE;           //"gif";
//            case "49492a00227105008037":
//                return "tif.tiff";
//            //16位色图
//            case "424d228c010*********":
//                return "bmp";
//            //24位色图
//            case "424d8240090000000000":
//                return "bmp";
//            //256位色图
//            case "424d8e1be30000000000":
//                return "bmp";
//            case "3c214441435459504520":
//                return "html";
//            case "526172211a0700c9073":
//                return "rar";
//            case "504b0304140000000800":
//                return "zip";
//            case "235468697320636f6e66":
//                return "ini";
//            case "4d5a9000030000000400":
//                return "exe";
//            case "49443303000000002176":
//                return "mp3";
//            case "49443303000000034839":
//                return "mp3case";
//            case "00000020667479706973":
//                return "mp4";
//            case "000001ba210001000180":
//                return "mpg";
//            case "3026b2758e66cf11a6d9":
//                return "wmv,asf";
//            case "52494646d07d60074156":
//                return "avi";
//            case "464c5601050000000900":
//                return "flv,f4v";
//            case "4d546864000000060001":
//                return "mid,midi";
//            default:
//                return "0000";
//        }
//
//    }
//
//
//    private static void write(String filePath, String s, boolean b) {
//        try {
//            filePath = java.net.URLDecoder.decode(filePath, "utf-8");
//            String[] split = filePath.split("\\\\");
//            //最后一个就是文件名
//            String fileName = split[split.length - 1];
//            //将文件名从文件路径中用空字符串给替掉，就相当于去掉了
//            String newFilePath = filePath.replace(fileName, "");
//            StringBuffer val = new StringBuffer(s);
//            File file = new PathResource(filePath).getFile();
//
//            if (!file.exists()) {
//                boolean mkdirs = new PathResource(newFilePath).getFile().mkdirs();
//                file.createNewFile();
//            }
//            FileOutputStream stream = new FileOutputStream(file, b);
//            stream.write((val + (System.getProperty("line.separator"))).getBytes());
//            stream.flush();
//            stream.close();
//        } catch (Exception e) {
//            // TODO: handle exception
//            e.printStackTrace();
//        }
//    }
//
//    /**
//     * 写入文件
//     */
//    public static void write(String filePath, String s) {
//
//        write(filePath, s, true);
//    }
//
//    /**
//     * 覆盖文件
//     */
//    public static void addFile(String filePath, String s) {
//        write(filePath, s, false);
//    }
//
//    public static String getFileStr(String filePath) {
//        return getFileStr(new File(filePath));
//    }
//
//    public static String getFileStr(File jsonFile) {
//        String jsonStr = null;
//        try {
////            File jsonFile = new File(filePath);
//
//            FileReader fileReader = new FileReader(jsonFile);
//            Reader reader = new InputStreamReader(new FileInputStream(jsonFile), "UTF-8");
//            int ch = 0;
//            StringBuffer sb = new StringBuffer();
//            while ((ch = reader.read()) != -1) {
//                sb.append((char) ch);
//            }
//            fileReader.close();
//            reader.close();
//            jsonStr = sb.toString();
//            return jsonStr;
//        } catch (IOException e) {
//            log.error(jsonFile + "(系统找不到指定的文件。)");
//        }
//        return jsonStr;
//    }
//
//
//    /**
//     * 给图片添加水印文字、可设置水印文字的大小、旋转角度、透明度
//     *
//     * @param logoText     水印内容
//     * @param img          原图片
//     * @param outputStream 输出流
//     * @param isMore       是否铺满
//     */
//    public static void markImageByText(String logoText, MultipartFile img, OutputStream outputStream, Integer H, Integer W, Float fillOpacity, Integer rotation, Boolean isMore) {
//        InputStream inputStream = null;
//        Graphics2D graphics = null;
//        BufferedImage buffImg = null;
//        // 1、读取源图片，Image获取图片宽度、高度
//        try {
//            inputStream = img.getInputStream();
//            Image scrImg = ImageIO.read(inputStream);
//            buffImg = new BufferedImage(scrImg.getWidth(null), scrImg.getHeight(null), BufferedImage.TYPE_INT_RGB);
//
//            // 2、得到画笔对象
//            graphics = buffImg.createGraphics();
//
//            // 3、设置对线段的锯齿状边缘处理
//            graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
//            graphics.drawImage(scrImg.getScaledInstance(scrImg.getWidth(null), scrImg.getHeight(null), Image.SCALE_SMOOTH), 0, 0, null);
//
//            // 4、设置水印倾斜度，这里是在图片的对角线上
//            // 对角线长度lengthOfDiagonal
//            double lengthOfDiagonal = Math.sqrt(Math.pow(buffImg.getWidth(), 2) + Math.pow(buffImg.getHeight(), 2));
//            double v = (Math.pow(buffImg.getWidth(), 2) + Math.pow(lengthOfDiagonal, 2) - Math.pow(buffImg.getHeight(), 2)) / (2 * buffImg.getWidth() * lengthOfDiagonal);
//            //get到了一个弧度数
//            double acos = Math.acos(v);
//            double myDegree = Math.toDegrees(acos);
//            //这里的负号决定对角线-Math.toRadians(myDegree)
//            graphics.rotate(-Math.toRadians(myDegree),
//                    (double) buffImg.getWidth() / 2,
//                    (double) buffImg.getHeight() / 2);
//
//            if (isMore) {
//                // 5、设置水印文字颜色
//                graphics.setColor(Color.DARK_GRAY);
//
//
//                // 6、获取源图片的宽度和高度
//                int width = scrImg.getWidth(null);
//                int heigth = scrImg.getHeight(null);
//
//
//                graphics.setFont(new Font("微软雅黑", Font.BOLD, 50));
//
//                //8、设置透明度
//                graphics.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP,
//                        fillOpacity));
//
//                //9、设置文字位置
////                FontDesignMetrics metrics = FontDesignMetrics.getMetrics(graphics.getFont());
//                FontMetrics metrics = graphics.getFontMetrics(graphics.getFont());
//                //获取文字宽度
//                int strWidth = metrics.stringWidth(logoText);
//
//                int xNum = width / strWidth + 1;
//
//                int yNum = heigth / 50 + 1;
//
//                int split = 5;
//
//                //多水印绘制
//                for (int i = 1; i <= 2 * yNum; i++) {
//                    int y = -heigth + 50 * i + 5 * split * i;
//                    for (int j = 0; j < xNum; j++) {
//                        int x = strWidth * j + 3 * split * j;
//
//                        graphics.drawString(logoText, x, y);
//                    }
//                }
//            } else {
//                // 5、设置水印文字颜色
//                graphics.setColor(Color.RED);
//
//                // 6、获取源图片的宽度和高度
//                int width = scrImg.getWidth(null);
//                int heigth = scrImg.getHeight(null);
//
//                // 7、设置水印文字大小（根据原图的宽、高度，我这里是哪个长就取哪个，再除上水印字符串长度，记为size）
//                int size = 0;
//                if (width >= heigth) {
//                    size = width / logoText.length();
//                } else {
//                    size = heigth / logoText.length();
//                }
//                //Font是JAVA中的字体类，PLAIN：普通样式常量；BOLD：粗体样式常量；ITALIC：斜体样式常量
//                //如下初始化对象:Font font = new Font("宋体" , Font.BOLD , 23)；该字体表示23磅粗体的宋体字
//                graphics.setFont(new Font("宋体", Font.PLAIN, size));
//
//                //8、设置透明度
//                graphics.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP,
//                        0.3f));
//
//                //9、设置文字位置
////                FontDesignMetrics metrics = FontDesignMetrics.getMetrics(graphics.getFont());
//                FontMetrics metrics = graphics.getFontMetrics(graphics.getFont());
//                //获取文字宽度
//                int strWidth = metrics.stringWidth(logoText);
//                int strHeight = metrics.getHeight();
//                //文字在画布上的坐标
//                int left = (width - strWidth) / 2;
//                //有条基线，加上ascent，相当于画布要向上移动（或是文字向下移），才能保证文字是居中的
//                int top = (heigth - strHeight) / 2 + metrics.getAscent();
//
//                //10、水印文字开始动工了，文字内容，x,y坐标
//                graphics.drawString(logoText, left, top);
//            }
//        } catch (IOException e) {
//
//        } finally {
//            //11、释放资源
//            graphics.dispose();
//            try {
//                inputStream.close();
//            } catch (IOException e) {
//                throw new RuntimeException(e);
//            }
//        }
//
//        //12、生成图片
//        try {
//            ImageIO.write(buffImg, "jpg", outputStream);
//            outputStream.flush();
//        } catch (IOException e) {
//            e.printStackTrace();
//        } finally {
//            try {
//                outputStream.close();
//            } catch (IOException e) {
//                throw new RuntimeException(e);
//            }
//        }
//
//    }
//
//    /**
//     * @param inputFile     输入流
//     * @param outputFile    输出流
//     * @param H             水印高
//     * @param W             水印宽
//     * @param fillOpacity   透明度
//     * @param rotation      倾斜度数
//     * @param waterMarkName 水印内容
//     * @param isTop         是否置于内容之上
//     * @description pdf添加水印的方法
//     */
//    public static void PDFAddWatermark(InputStream inputFile, OutputStream outputFile, Integer H, Integer W, Float fillOpacity, Integer rotation, String waterMarkName, Boolean isTop) {
//        try {
//            // 水印的高和宽（参数可调节）
//            int textH = H;
//            int textW = W;
//            // 间隔距离（参数可调节）
//            int interval = 30;
//            // 切记这里的参数是文件的路径 ，路径必须是双斜杠的如F:\\test.pdf，不能是F:/test.pdf 或者F:\test.pdf
//            PdfReader reader = new PdfReader(inputFile);
//            PdfStamper stamper = new PdfStamper(reader, new BufferedOutputStream(outputFile));
//            BaseFont base = BaseFont.createFont("STSong-Light", "UniGB-UCS2-H", BaseFont.EMBEDDED);
//            PdfGState gs = new PdfGState();
//            gs.setFillOpacity(fillOpacity);//改透明度0.2f
//            gs.setStrokeOpacity(0.4f);
//            int total = reader.getNumberOfPages() + 1;
//            JLabel label = new JLabel();
//            label.setText(waterMarkName);
//            PdfContentByte under;
//
//            // 可添加多个水印
//            Rectangle pageRect = null;
//            FontMetrics metrics;
//            label.setText(waterMarkName);
//            metrics = label.getFontMetrics(label.getFont());
//            for (int i = 1; i < total; i++) {
//                pageRect = reader.getPageSizeWithRotation(i);
//                if (isTop)
//                    // 在内容上方加水印
//                    under = stamper.getOverContent(i);
//                else
//                    // 在内容下方加水印
//                    under = stamper.getUnderContent(i);
//                under.saveState();
//                under.setGState(gs);
//                under.beginText();
//                under.setFontAndSize(base, 20);
//                // 水印文字成30度角倾斜
//                for (int height = interval + textH; height < pageRect.getHeight();
//                     height = height + textH * 3) {
//                    for (int width = interval + textW; width < pageRect.getWidth() + textW;
//                         width = width + textW * 2) {
//                        under.showTextAligned(Element.ALIGN_LEFT
//                                , waterMarkName, width - textW,
//                                height - textH, rotation);//默认30较好
//                    }
//                }
//                // 添加水印文字
//                under.endText();
//            }
//            stamper.close();
//            reader.close();
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
//
//    /**
//     * @param files        文件数组
//     * @param outputStream 输出流
//     * @date 2023/5/19 11:44
//     * @description pdf文件合并
//     */
//    public static void pdfMerge(List<MultipartFile> files, OutputStream outputStream) {
//        boolean retValue = false;
//        Document document = null;
//        try {
//            document = new Document(new PdfReader(files.get(0).getInputStream()).getPageSize(1));
//            PdfCopy copy = new PdfCopy(document, outputStream);
//            document.open();
//            for (int i = 0; i < files.size(); i++) {
//
//                PdfReader reader = new PdfReader(files.get(i).getInputStream());
//                int n = reader.getNumberOfPages();
//                for (int j = 1; j <= n; j++) {
//                    document.newPage();
//                    PdfImportedPage page = copy.getImportedPage(reader, j);
//                    copy.addPage(page);
//                }
//            }
//            retValue = true;
//        } catch (Exception e) {
//            e.printStackTrace();
//        } finally {
//            document.close();
//        }
//    }
//
//    /**
//     * @param inputStream  输入流
//     * @param outputStream 输出流
//     * @param password     密码
//     * @date 2023/5/19 16:47
//     * @description
//     */
//    public static void pdfEncryption(InputStream inputStream, OutputStream outputStream, String password) throws BadPasswordException, DocumentException, IOException {
//        PdfReader reader = new PdfReader(inputStream);
//        PdfStamper stamper = new PdfStamper(reader, outputStream);
//        // 设置密码
//        stamper.setEncryption(password.getBytes(), password.getBytes(), PdfWriter.ALLOW_PRINTING, PdfWriter.ENCRYPTION_AES_128);
//        stamper.close();
//        reader.close();
//    }
//
//    public static void pdfRemoveEncryption(InputStream inputStream, OutputStream outputStream, String password) throws BadPasswordException, DocumentException, IOException {
//        PdfReader reader = new PdfReader(inputStream, password.getBytes());
//        PdfStamper stamper = new PdfStamper(reader, outputStream);
//        // 设置密码
//        stamper.setEncryption(null, null, PdfWriter.ALLOW_PRINTING, PdfWriter.ENCRYPTION_AES_128);
//        stamper.close();
//        reader.close();
//    }
//
//    /**
//     * @param fileName 文件名
//     * @param suffix   需要验证的拓展名
//     * @date 2023/5/19 17:03
//     * @description
//     */
//    public static Boolean checkSuffix(String fileName, String suffix) {
//        return getSuffix(fileName).equalsIgnoreCase(suffix);
//    }
////
//
//    /**
//     * @param source
//     * @param dest
//     * @date 2023/5/16 15:15
//     * @description 复制文件
//     */
//    public static boolean copyFiles(File source, File dest) {
//        try {
//            Files.copy(source.toPath(), dest.toPath());
//        } catch (IOException e) {
//            throw new RuntimeException(e);
//        }
//        return true;
//    }
//
//
//    /**
//     * @param data 图片的数据
//     * @param path 储存的文件路径
//     * @return void
//     * @author Yu.
//     * @Description //
//     * @Date 2023/5/29 11:36
//     **/
//    public static void byte2image(byte[] data, String path) {
//        if (data.length < 3 || path.equals("")) return;
//        try {
//            FileImageOutputStream imageOutput = new FileImageOutputStream(new File(path));
//            imageOutput.write(data, 0, data.length);
//            imageOutput.close();
//            System.out.println("让图片成功，请在 " + path);
//        } catch (Exception e) {
//            System.out.println("Exception: " + e);
//            e.printStackTrace();
//        }
//    }
//
//
//    public static File createDocx(String dirFile) {
//        // 创建一个新的Word文档
//        XWPFDocument document = new XWPFDocument();
//
//        // 创建一个段落
//        XWPFParagraph paragraph = document.createParagraph();
//        XWPFRun run = paragraph.createRun();
//        run.setText("Hello, World!");
//
//        // 保存文档到文件
//        try {
//            FileOutputStream out = new FileOutputStream(dirFile);
//            document.write(out);
//            out.close();
//            System.out.println("Word文件创建成功！");
//        } catch (Exception e) {
//            System.out.println("创建Word文件时发生错误：" + e.getMessage());
//        }
//        return new File(dirFile);
//    }
//
//    public static File createExcel(String dirFile) {
//        Workbook workbook = new XSSFWorkbook();
//        Sheet sheet = workbook.createSheet("Sheet1");
//        Row row = sheet.createRow(0);
//        Cell cell = row.createCell(0);
//        cell.setCellValue("Hello");
//        try {
//            FileOutputStream fileOut = new FileOutputStream(dirFile);
//            workbook.write(fileOut);
//            fileOut.close();
//        } catch (IOException e) {
//            System.out.println("创建excel文件时发生错误：" + e.getMessage());
//        }
//        return new File(dirFile);
//    }
//
//    public static File createPpt(String dirFile) {
//        // 创建一个新的PPT文档
//        XMLSlideShow ppt = new XMLSlideShow();
//
//        // 创建一个空白的幻灯片
//        XSLFSlide slide = ppt.createSlide();
//
//        // 在幻灯片上添加一个标题
//        XSLFTextShape title = slide.createTextBox();
//        title.setAnchor(new Rectangle2D.Double(50, 50, 500, 50));
//        XSLFTextParagraph paragraph = title.addNewTextParagraph();
//        XSLFTextRun run = paragraph.addNewTextRun();
//        run.setText("Hello, World!");
//        run.setFontSize(24.0);
//
//        // 保存PPT文件
//        try (FileOutputStream out = new FileOutputStream(dirFile)) {
//            ppt.write(out);
//            System.out.println("PPT generated successfully!");
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//        return new File(dirFile);
//    }
//
//    /**
//     * @param directory
//     * @return void
//     * @author Yu.
//     * @Description // 删除目录数据
//     * @Date 2023/3/7 10:33
//     **/
//    public static void deleteDirectory(File directory) {
//        try {
//            Files.walk(directory.toPath())
//                    .filter(Files::isRegularFile)
//                    .map(Path::toFile)
//                    .forEach(File::delete);
//        } catch (IOException e) {
////            throw new RuntimeException(e);
//        }
//    }
//
//
//    public static void deleteDirectoryAll(File directory) {
//        try {
//            Files.walk(directory.toPath())
//                    .sorted(Comparator.reverseOrder())
//                    .forEach(path -> {
//                        try {
//                            Files.delete(path);
//                        } catch (IOException e) {
//
//                        }
//                    });
//        } catch (IOException e) {
////            throw new RuntimeException(e);
//        }
//    }
//
//
//    /**
//     * @param path
//     * @return void
//     * @author Yu.
//     * @Description // 检查文件夹
//     * @Date 2023/11/22 11:41
//     **/
//    public static void folderCheck(String path) {
//        File folder = new File(new String(path.getBytes(StandardCharsets.UTF_8), StandardCharsets.UTF_8));
//        if (!folder.exists() && !folder.mkdirs()) {
//            // 如果创建文件夹不成功，可以根据需要进行处理
//            System.out.println("创建文件夹失败：" + path);
//        } else {
//            System.out.println("创建文件：" + path);
//        }
//    }
//
//    public static File createUniqueFileName(String path, String fileName) {
//        File targetFile = new File(path, fileName);
//        int count = 1;
//        String baseName = FileUtil.getPrefix(fileName);
//        String extension = FileUtil.extName(fileName);
//        while (targetFile.exists()) {
//            fileName = baseName + " (" + count + ")." + extension;
//            targetFile = new File(path, fileName);
//            count++;
//        }
//
//        return targetFile;
//    }
//
//
//    public static void download(HttpServletResponse response, File file) {
//        try {
////            String name = file.getName();
////            FileInputStream fileInputStream = new FileInputStream(file);
////            BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
////            byte[] bytes = new byte[bufferedInputStream.available()];
////            bufferedInputStream.read();
////            bufferedInputStream.close();
////
////            response.reset();
////            response.setCharacterEncoding("UTF-8");
////            response.setHeader("Content-Disposition","attachment;filename="+URLEncoder.encode(name, "UTF-8"));
//////            response.addHeader("Content-Length",""+file.length());
////            OutputStream os = new BufferedOutputStream(response.getOutputStream());
////            response.setContentType("application/octet-stream");
////            os.write(bytes);
////            os.flush();
//
//            InputStream inputStream = new FileInputStream(file);
//            response.setContentType("application/octet-stream");
//            String filename = file.getName();
//            response.addHeader("Content-Disposition", "attachment; filename=" + URLEncoder.encode(filename, "UTF-8"));
//            ServletOutputStream outputStream = response.getOutputStream();
//            byte[] b = new byte[1024];
//            int len;
//            while ((len = inputStream.read(b)) > 0) {
//                outputStream.write(b, 0, len);
//            }
////            outputStream.close();
////            outputStream.flush();
//            inputStream.close();
//            outputStream.close();
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//
//    }
//
//    /**
//     * @param fileName
//     * @return java.lang.String
//     * @author Yu.
//     * @Description // 处理 文件 是否有特殊符号 称处理 静默处理
//     * @Date 2023/12/13 15:31
//     **/
//    public static String fileNameProcessingSilence(String fileName) {
//        return fileNameProcessing(fileName, true);
//    }
//
//    /**
//     * @param fileName
//     * @return java.lang.String
//     * @author Yu.
//     * @Description // 处理 文件 是否有特殊符号 称处理 抛出异常
//     * @Date 2023/12/13 15:32
//     **/
//    public static String fileNameProcessingException(String fileName) {
//        return fileNameProcessing(fileName, false);
//    }
//
//    /**
//     * @param fileName
//     * @param b        true静默处理   false 抛出异常
//     * @return java.lang.String
//     * @author Yu.
//     * @Description // 处理 文件 是否有特殊符号 称处理
//     * @Date 2023/12/13 13:45
//     **/
//    public static String fileNameProcessing(String fileName, boolean b) {
////       检查文件长度文件的长都
//        if (fileName.length() > 200) {
//            if (b) {
//                fileName = fileName.substring(0, 200);
//            } else {
//                throw new BadRequestException("超过文件命名规则上限");
//            }
//        }
//        //不同系统有不同的 命明规则
////        String os = System.getProperty("os.name");
////        if(os.toLowerCase().startsWith(ElAdminConstant.WIN)) { // 处理特殊符号
////            fileName = fileName.replaceAll("[\\/:*?\"<>|]", "");
////        }else {
////            fileName = fileName.replaceAll("[@#$%^&*\\/]", "");
//        String url = "[@#$%^&*\\/:*?\"<>|]";
//        if (fileName.matches(url)) {
//            if (b) {
//                fileName = fileName.replaceAll("", "");
//            } else {
//                throw new BadRequestException("超过文件命名规则上限");
//            }
//        }
//
//
////        }
//        return fileName;
//    }
//
//
//    public static void downloadFileToFrontEnd(String path, String fileName, HttpServletResponse response) {
//        try {
//            File file = new File(path + File.separator + fileName);
//
////            long length = ;
////            file.
//            //获取文件大小
//            String size = String.valueOf(file.length());
//
//            InputStream fileStream = new FileInputStream(path + File.separator + fileName);
//
////            String filename = URLEncoder.encode(fileName, "UTF-8");
//            String filename = fileName;
//            String header = response.getHeader("User-Agent").toUpperCase();
//            if (header.contains("MSIE") || header.contains("TRIDENT") || header.contains("EDGE")) {
//                fileName = URLEncoder.encode(fileName, "utf-8");
//                //IE下载文件名空格变+号问题
//                filename = fileName.replace("+", "%20");
//            } else {
//                filename = new String(fileName.getBytes(), "ISO8859-1");
//            }
//
//
//            //设置文件流的名称
////            response.setHeader("Content-Disposition", "attachment;filename=" + filename + ";filename*=UTF-8" + filename);
//            response.setHeader("Content-Disposition", "attachment;filename=" + filename );
////            response.addHeader("Access-Control-Allow-Origin", "*"); // 实现跨域
//            // 列表哪些header可以作为响应的一部分暴露给外部（除了默认的七种，其他的是不暴露给外部的）
//            response.setHeader(com.google.common.net.HttpHeaders.ACCESS_CONTROL_EXPOSE_HEADERS, com.google.common.net.HttpHeaders.CONTENT_DISPOSITION);
//            response.setContentType("application/x-download"); //告诉前端这是一个下载文件
//
//            response.setContentLengthLong(Long.valueOf(size));
//            ServletOutputStream servletOutputStream = response.getOutputStream();
//            int len;
//            byte[] buffer = new byte[1024];
//            while ((len = fileStream.read(buffer)) > 0) {
//                servletOutputStream.write(buffer, 0, len);
//            }
//            servletOutputStream.flush();
//            fileStream.close();
//            servletOutputStream.close();
//        } catch (Exception e) {
//            log.error("Exception", e);
//            throw new BadRequestException("下载异常");
//        }
//
//
//    }
//
//
//    /**
//     * @param fileUrl
//     * @return java.io.File
//     * @author Yu.
//     * @Description // 下载文件到本地
//     * @Date 2024/3/5 9:07
//     **/
//    public static File downloadFileToLocal(String fileUrl) {
//
//
//        return new File(fileUrl);
//    }
//
//
//    public static void main(String[] args) {
//        String filePath = "D:\\ecm\\file\\tmp\\download";
//        File file = new File(filePath);
//        deleteDirectory(file);
//
////        deleteDirectoryAll(file);
//    }
//
//
//
//    /**
//     * 通过OnlyOffice 将文件转换成pdf的下载流
//     * @param fileUrl       文件的下载流地址
//     * @param fileType      文件原始类型（后缀）
//     * @param key           缓存中的key
//     * @param outputType    转换为的类型（后缀）
//     * @param title         转换后的文件名称
//     */
//    public static String convertToPdf(String fileUrl,String fileType,String key,String outputType,String title){
//        OnlineConfig bean = SpringUtil.getBean(OnlineConfig.class);
//        String url = bean.getOnlyOffice() + "/ConvertService.ashx";
//        try {
//            URL obj = new URL(url);
//            HttpURLConnection con = (HttpURLConnection) obj.openConnection();
//
//            // 添加请求头
//            con.setRequestMethod("POST");
//            con.setRequestProperty("Content-Type", "application/json");
//
//            // 构建参数
//            JSONObject parameters = new JSONObject();
//            parameters.put("async", false);
//            parameters.put("filetype", fileType);
//            parameters.put("key", key);
//            parameters.put("outputtype", outputType);
//            parameters.put("title", title);
//            parameters.put("url", fileUrl);
//            // 发送POST请求
//            con.setDoOutput(true);
//            DataOutputStream wr = new DataOutputStream(con.getOutputStream());
//            wr.writeBytes(parameters.toJSONString());
//            wr.flush();
//            wr.close();
//
//            // 读取响应
//            BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
//            String inputLine;
//            StringBuffer response = new StringBuffer();
//
//            while ((inputLine = in.readLine()) != null) {
//                response.append(inputLine);
//            }
//            in.close();
//            // 创建一个DocumentBuilderFactory对象
//            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
//
//            // 创建一个DocumentBuilder对象
//            DocumentBuilder builder = factory.newDocumentBuilder();
//            // 使用DocumentBuilder解析XML输入流，得到一个Document对象
//            org.w3c.dom.Document doc = builder.parse(new InputSource(new StringReader(response.toString())));
//
//            // 获取根元素
//            org.w3c.dom.Element root = doc.getDocumentElement();
//
//            // 获取<FileUrl>标签
//            NodeList fileUrlList = root.getElementsByTagName("FileUrl");
//            Node node = fileUrlList.item(0);
//            return node.getTextContent();
//        }catch (Exception e) {
//
//        }
//
//        return null;
//    }
//
//    public static String tmsFileCheck(String suffix){
//        String path =  null;
//        switch (suffix) {
//            case "mp4":
//                path = "videos";
//                break;
//            case "png":
//            case "jpg":
//            case "jpeg":
//            case "gif":
//                path = "images";
//                break;
//            case "doc":
//            case "docx":
//            case "ppt":
//                path = "word";
//                break;
//            case "pdf":
//                path = "PDF";
//                break;
//            case "zip":
//                path = "zip";
//                break;
//            case "rar":
//                path = "rar";
//                break;
//        }
//        return path;
//    }
//
//
//    public static String getSizeUnit(Long size) {
//        // 将size转换为double类型，以便进行数学计算
//        Long val = size;
//        // 检查大小是否为NaN，尽管在long类型中这不可能，但为了保持逻辑完整性，这里假设val为double类型
//        if (Double.isNaN(val)) {
//            return "-";
//        }
//        // 检查大小是否为负数
//        if (val < 0) {
//            return "-";
//        }
//
//        // 定义文件大小单位数组
//        String[] units = {"B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"};
//        // 计算当前大小对应的单位指数，即确定大小处于哪个单位范围内
//        int temp = (int) Math.floor(Math.log(val) / Math.log(2));
//        // 确保单位指数不小于0
//        if (temp < 1) {
//            temp = 0;
//        }
//        // 计算并选择合适的单位索引，防止数组越界
//        int unitIndex = Math.min(temp / 10, units.length - 1);
//        // 根据选中的单位，计算转换后的值
//        double val1 = val / Math.pow(2, 10 * unitIndex);
//
//        // 格式化输出，保留两位小数
//        DecimalFormat df = new DecimalFormat("#.##");
//        String formattedVal = df.format(val1);
//
//        // 返回格式化后的大小和单位
//        return formattedVal + " " + units[unitIndex];
//    }
//
//}
